home *** CD-ROM | disk | FTP | other *** search
/ Pascal Super Library / Pascal Super Library (CW International)(1997).bin / DEBUG / WATCHES / WATCHES.TXT < prev    next >
Text File  |  1996-06-21  |  24KB  |  748 lines
  1. (*
  2.  
  3.  
  4.      See/text-search in file COMM.TXT for "WATCHES.TXT".
  5.  
  6.  
  7.      WATCHES  TXT   :watches & how to format them; values & how they
  8.                      are stored in memory; TP-IDE; (guess from 6.0 onwards)
  9.  
  10.   ................................................................
  11.   "Beginners only"  {to skip, text-search "WATCH-FORMATS"
  12.      Watches invisible ?
  13.        UNITs
  14.      Watches invisible after CTRL-F9 and a run-error
  15.      Watches = Variables only?
  16.   ................................................................
  17.   WATCH-FORMATS
  18.   VALUE & HOW IT IS STORED
  19.    POINTERS
  20.   MANY VARS TO DISPLAY
  21.   BINARY FORMAT
  22.  
  23.   ================================================================
  24.  
  25.  
  26.   ................................................................
  27.  
  28.  
  29.   "Beginners only"  {to skip, text-search "WATCH-FORMATS"
  30.  
  31.      Watches are what you get via eg. CTRL+F7. You put variables
  32.      in the watches-window. It watches what the variables are
  33.      looking at. To watch them carefully, their value is closely
  34.      monitored. If you want to keep a close eye on this, you can
  35.      split your monitor with ALT-W, T, and have a look at the
  36.      watches in the lower window.
  37.  
  38.  
  39.      (BTW, you can change a value with ALT+D, E while the program is
  40.       "running", i.e. while debugging.
  41.      )
  42.  
  43.  
  44.      Watches invisible ?
  45.        Well, firstly you need to enable the compiler to compile
  46.        with the necessary information for debugging, before you
  47.        running a program step by step - and watching any variables.
  48.        See the online-help on eg.: $D $L
  49.        (put cursor on $D, press CTRL-F1}
  50.        ((also, there are some notes in file: Define.txt of upload
  51.          loader.zip
  52.        ))
  53.  
  54.        UNITs
  55.          Note that if a program uses units you can step through
  56.          their routines, only if the units are compiled with
  57.          the corresponding $... specifications.
  58.  
  59.          Also: If you press F8 and the highlighted line jumps to
  60.          the "BEGIN" of the main program, you can then step through
  61.          the init-code (BEGIN...END part of units) of all such
  62.          compiled units by pressing F7.
  63.  
  64.          You can however, simply put an END instead of a BEGIN END
  65.          in the interface of an unit which would "avoid" this. If
  66.          there is no "real" ini-code, well, you can still put BEGIN END
  67.          in a unit, which then perhaps serves to check which units are
  68.          loaded when (stepping via F7), etcetera.
  69.  
  70.          Units as CRT, SYSTEM, etc. are not compiled for this kind of
  71.          "stepping" via F7.
  72.  
  73.  
  74.        Hence, you'd need to press F7 or F8 to start debugging
  75.        before watches "become visible". Also, you'd need to take
  76.        care that watches inside procedures might have the same
  77.        name as global variables. Inside a procedure P, the
  78.        watch-variable "w" represents the "w" of the procedure,
  79.        outside the procedure it refers to the global variable "w".
  80.  
  81.  
  82.        You can specify a variable however:
  83.  
  84.        Program x;
  85.        var w:word;
  86.          procedure a;
  87.          var w:word;
  88.          begin
  89.          end;
  90.        begin
  91.          a;
  92.        end.
  93.  
  94.        Here you can use: "x.w" for the global variable "w", and
  95.        "a.w" for the procedure's variable "w"
  96.  
  97.        The watch "w" may refer to any of these, depending on
  98.        whether "the program" is *currently* "inside the procedure"
  99.        or not.
  100.  
  101.        ((
  102.          Other specifications can apply to the units CRT, DOS, etc.
  103.          eg.: "crt.lastmode". You can of course also use this to
  104.          "de-reference" procedure/functions. "built-in" routines
  105.          are de-referenced with System.*
  106.          eg.:
  107.            program x; uses crt;
  108.            {---------------------------------------------------------------}
  109.            PROCEDURE writeln (s:string);
  110.            BEGIN
  111.              system.writeln(#7,s); {#7=bell character (ASCII), beeps}
  112.            END;
  113.            {---------------------------------------------------------------}
  114.            BEGIN
  115.              ClrScr;
  116.              writeln('...NET !');
  117.              System.Writeln('...first service.');
  118.              System.Writeln('...quiet, please...');
  119.              writeln('...OUT !');
  120.            END.
  121.        ))
  122.  
  123.  
  124.      Watches invisible after CTRL-F9 and a run-error
  125.        When your program stops with a run-error the watches of a
  126.        procedure might no longer be "visible". For test-purposes
  127.        you might instead use a global variable, which will still
  128.        be visible:
  129.        (eg included via $define... compiling)
  130.        ((about $define, see file DEFINE.TXT / upload: Loader.zip))
  131.  
  132.        For example:
  133.  
  134.        Program x;
  135.        var w:word;
  136.          procedure a;
  137.          var b:byte;
  138.          begin
  139.            b:=4;
  140.            w:=4;
  141.            runError;
  142.            {<function to artificially cause a runError as if a "real"
  143.             error had occurred.
  144.            }
  145.          end;
  146.        begin
  147.          a;
  148.        end.
  149.  
  150.        Follwing a screen-copy *after* this sample code has been run:
  151.  
  152.  
  153.    File  Edit  Search  Run  Compile  Debug  Tools  Options  Window  Help
  154.  ╔═[■]════════════════════════════ WATCHES.TXT ═══════════════════════════1═[·]═╗
  155.  ║ Error 0: Runtime error.                                                      ·
  156.  ║         procedure a;                                                         ▒
  157.  ║         var b:byte;                                                          ▒
  158.  ║         begin                                                                ■
  159.  ║           b:=4;                                                              ▒
  160.  ║           w:=4;                                                              ▒
  161.  ║           runError;                                                          ▒
  162.  ║           {function to artificially cause a runError as if a "real"          ▒
  163.  ║            error had occurred.                                                ▒
  164.  ║           }                                                                  ▒
  165.  ║         end;                                                                 ▒
  166.  ║       begin                                                                  ▒
  167.  ║         a;                                                                   ▒
  168.  ║       end.                                                                   ·
  169.  ╚═·════ 73:1 ═════·■▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒·─┘
  170.  ┌────────────────────────────────── Watches ─────────────────────────────2─────┐
  171.  │ b: Unknown identifier                                                        │
  172.  │ w: 4                                                                         │
  173.  │                                                                              │
  174.  │                                                                              │
  175.  │                                                                              │
  176.  └──────────────────────────────────────────────────────────────────────────────┘
  177.   F1 Help  F2 Save  F3 Open  Alt+F9 Compile  F9 Make  Alt+F10 Local menu
  178.  
  179.        Note:  Variable w is still "visible", when variable b is not.
  180.  
  181.  
  182.  
  183.  
  184.      Watches = Variables only?
  185.        Not necessarily. You can easily enter any "expression"
  186.        If it is wrong, the IDE will tell you - that's about all.
  187.        Invalid format-specifiers are mostly be simply ignored.
  188.  
  189.        Not forgetting that if you don't have a pocket calculator
  190.        handy, you can also do calculations with the IDE. Later on,
  191.        I'll show how this "calculator" could also convert decimal
  192.        values to hexa-decimal.
  193.  
  194.  
  195.        Program x;
  196.        var w:word;
  197.        begin
  198.          w:=4;
  199.        end.
  200.  
  201.        ╔═[■]══════════════════════════════ Watches ══════
  202.        ║ w: 4
  203.        ║ w * 30 - 50: 70
  204.        ║ 1.25 * 4 + (1.2 / 3 ): 5.4
  205.        ║ Oh no, it's an: Unknown identifier
  206.        ║ trunc(2.4) * trunc(2.5): 4
  207.        ║ w mod 2: 0
  208.        ║ w > 2.5: True
  209.        ║ not true: False
  210.  
  211.        ...etc...type-casts...etc...
  212.  
  213.  
  214.  
  215.  
  216.  
  217.  
  218.  
  219.   ................................................................
  220.  
  221.  
  222.  
  223.  
  224.   WATCH-FORMATS
  225.  
  226.      You can specify a couple of formats with which the value of a
  227.      "watch-variable" is to be displayed. And, if you want ice for
  228.      dessert, you can even combine them. That is, both combinations
  229.      of values and/or variables.
  230.  
  231.      I assume this to be easier to explain by giving so called
  232.      screen-dumps as examples. You can also use this file in the
  233.      IDE and check the code yourself. If you want to run some
  234.      sample code, simply move the end-of-comment sign (the
  235.      comment sign with an asterix* ) above the sample code's
  236.      "program" start-line.
  237.  
  238.  
  239.      By default strings and arrays might appear quite "ugly":
  240.  
  241.  
  242.      program x; var s:string; a:array[1..100] of char; b:byte;
  243.      begin
  244.        s[0]:=#100; for b:=32 to 132 do s[b-31]:=char(b);
  245.        for b:=100 to 200 do a[b-99]:=char(b);
  246.      end.
  247. ┌────────────────────────────────── Watches ─────────────────────────────1─────┐
  248. │ s: ' !"#$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg│
  249. │ a: ('d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','│
  250. │                                                                              │
  251.  
  252.      Both variables do not fit on the screen, and you'd need to use
  253.      CURSOR-RIGHT etc. to see "higher values".
  254.  
  255.      You could try this format specifier for variables:
  256.        s[40],40
  257.      => beginning with element #40, display 40 "elements".
  258.  
  259. ╔═[■]══════════════════════════════ Watches ═════════════════════════════1═[·]═╗
  260. ║ s: ' !"#$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg·
  261. ║ s[40],40: 'G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W'■
  262. ║ a: ('d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','▒
  263.  
  264.  
  265.  
  266.  
  267.      Sometimes, you might prefer to see values in hexa-decimal format.
  268.      You can add ",h" - but this won't work with strings/chars. Yet,
  269.      alternatively you can specify ",m" which displays "WHAT IS ACTUALLY
  270.      STORED IN MEMORY", which displays in hexa-decimal format.
  271.  
  272. ┌────────────────────────────────── Watches ─────────────────────────────1─────┐
  273. │ s: ' !"#$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg│
  274. │ s[40],40: 'G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W'│
  275. │ s[40],40m: 47 48 49 4A 4B 4C 4D 4E 4F 50 51 52 53 54 55 56 57 58 59 5A 5B 5C │
  276.  
  277.  
  278.  
  279.  
  280.      "s[40],40" has "s" displayed like the array-of-char "a" was displayed.
  281.      This can be considered ugly, since one char uses 4 "digits" to get
  282.      displayed, eg: 'G',
  283.  
  284.      For vanilla ice-cream, you could alternatively combine the format-
  285.      specifiers ",c" (char) with ",m":
  286.  
  287. ╔═[■]══════════════════════════════ Watches ═════════════════════════════1═[·]═╗
  288. ║ s: ' !"#$%&''()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefg·
  289. ║ s[40],40: 'G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W'▒
  290. ║ s[40],40mc: 'GHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn'                       ■
  291. ║ a: ('d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','▒
  292. ║ a,mc: 'defghijklmnopqrstuvwxyz{|}~ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñѪº¿⌐·
  293.  
  294.  
  295.      The "mc" specifier is s.th to keep in mind whenever you want
  296.      to format as "ASCII-code chars".
  297.  
  298.      File WATCHES2.txt gives an example for ASM-registers as
  299.      "watches as chars" - and for other points discussed further on
  300.      here in this file.
  301.  
  302.      ((
  303.        BTW, the ",c" is meant to display the #0..#31 as "ASCII-chars"
  304.        (opposed to displaying them as #0, #1, etc.) Yet, this is not
  305.        a good example to include, since it may cause havoc when printing.
  306.        An example for this & "strings"-const is in file Watches3.txt
  307.      ))
  308.  
  309.  
  310.  
  311.      Now, if you want to see decimal/Hexa-decimal equivalents,
  312.      these are some ideas:
  313. ┌────────────────────────────────── Watches ─────────────────────
  314. │ s[40],40: 'G','H','I','J','K','L','M','N','O','P','Q','R','S','
  315. │ s[40],40m: 47 48 49 4A 4B 4C 4D 4E 4F 50 51 52 53 54 55 56 57 5
  316. │ s[40],40md: 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
  317. │ 'G': 'G'
  318. │ byte('G'): 71
  319. │ byte('G'),h: $47
  320. │
  321.  
  322.  
  323.  
  324.  
  325.   VALUE & HOW IT IS STORED
  326.  
  327.      ",m" might help to visualize how "multi-byte unities" are actually
  328.      stored in memory:
  329.  
  330.      program x;
  331.      var pB:^Byte; w:word;
  332.      begin
  333.        w:=259;
  334.        pB:=@w;
  335.      end.
  336.      ┌────────────────────────────────── Watches ───────────────────────
  337.      │ pB^,h: $3
  338.      │ pB^,2m: 03 01
  339.      │ w: 259
  340.      │ w,h: $103
  341.      │ w,m: 03 01
  342.  
  343.  
  344.      ",m" by default displays memory starting from the start-address
  345.      of the variable "over the length/size" of the variable.
  346.  
  347.      As you can see the 2-bytes variable "w" has the hexa-VALUE $0103.
  348.      Yet, it is STORED as $0301 - as "w,m" indicates.
  349.  
  350.      Also, see below about $A+ and $A-  (Text-search: "!!!")
  351.  
  352.      As pB is a pointer on a single byte only, pB^ does represent just
  353.      one byte of w instead of its two bytes. Therefore the format
  354.      specifier ",2" to display the two bytes stored in memory, "pB^,2m"
  355.  
  356.      Since the value of pB^ is $03, it obviously points to what "w,m"
  357.      displays as the "high-byte" ("left-most" byte). More about this
  358.      will follow later on, when giving a suggestion for "Binary format"
  359.      and all that jazz.
  360.  
  361.  
  362.  
  363.  
  364.  
  365.    POINTERS
  366.  
  367.      ( This links to file COMM.TXT (text-search for "WATCHES.TXT")
  368.        (about pointers<->strings as parameters for child-processes)
  369.        upload: loader.zip
  370.      )
  371.  
  372.      PROGRAM x;
  373.      {$D+,L+,I+,R+,S+,Q+,V+,Y+}
  374.      VAR s:string; pByte:^byte;
  375.      BEGIN
  376.        pByte:= PTR( $3344, $5566 ); {artificial value for testing only}
  377.  
  378.        s[0]:=#4; {<set length to 4}
  379.  
  380.        {>move the "address-pByte-is-pointing-to" to the string}
  381.        move( pByte , s[1], 4);  { pByte = @pByte^ }
  382.      END.
  383.      {-----------------------------------------------------------------}
  384. ╔═[■]══════════════════════════════ Watches ══════════════════════
  385. ║ pByte: Ptr($3344,$5566)
  386. ║ pByte,m: 66 55 44 33
  387. ║ @pByte^: Ptr($3344,$5566)
  388. ║ @pByte^,p: 3344:5566
  389. ║ s: 'fUD3'
  390. ║ s,m: 04 66 55 44 33 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  391. ║ s[1],4m: 66 55 44 33
  392. ║
  393.  
  394.      As you can see, while a pointer is considered to be Ptr($3344,$5566)
  395.      that is Ptr($segment,$offset), it is differently stored in memory.
  396.      Here as: pByte,m: 66 55 44 33,
  397.  
  398.      Which is reflected in the type PtrRec used in unit WinDos to
  399.      "access" a pointer:
  400.        TYPE
  401.          PtrRec = RECORD
  402.                     ofs, seg:word;
  403.                   END;
  404.  
  405.      Now, to obtain the word-value of eg. the segment you might eg. use
  406.      the function seg():
  407.        "w:=seg(pointerVar)"
  408.      or type-casting:
  409.        "w:= PtrRec( pointerVar ).seg"  (etc.... word()<-> offset, etc.)
  410.  
  411.      In a Bpascal forum message, Peter Below (CIS address 100113,1101)
  412.      strongly recommended to me using type-casting, saying that, the
  413.      Seg/Ofs functions would actually load the value into CPU-registers,
  414.      and that with invalid values this would cause a GPF.
  415.  
  416.  
  417.  
  418.  
  419.  
  420.   MANY VARS TO DISPLAY
  421.      If you have many byte/words as watches, each will "take up" one line.
  422.      Even if they might not need more than a couple of columns to display
  423.      a value.
  424.  
  425.      To not waste all those lines, you might eg. declare them following
  426.      one another in the var-statement, eg:  var a,b,c,d:byte;
  427.  
  428.      program x;
  429.      var a,b:byte; c:byte; d:byte;
  430.          s:string;
  431.          e:byte;
  432.      begin
  433.        a:=1;b:=2;c:=3;d:=4;e:=5;
  434.        move(a,s[1],5);
  435.      end.
  436. ┌────────────────────────────────── Watches ─────────────────────────────
  437. │ a: 1
  438. │ b: 2
  439. │ c: 3
  440. │ d: 4
  441. │ e: 5
  442. │ a,5: 1,2,3,4,0
  443. │ s,m: 00 01 02 03 04 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  444.  
  445.      Note
  446.       -"a,5" does not display "e", as variable "s" was declared before "e".
  447.       -(BTW, the 0 in a,5 is obviously the length byte of s)
  448.  
  449.  
  450.      (((
  451.      ....BTW...BEGIN...................
  452.          While using
  453.            var a,b:byte; c:byte;
  454.          or
  455.            var a,b,c:byte;"
  456.          did not seem to make any difference, I found a difference when
  457.          using "var" several times:
  458.  
  459.          program x;
  460.          var a,b:byte;
  461.          var c:byte;
  462.          var d:byte;
  463.          var s:string;
  464.              e:byte;
  465.          begin
  466.            a:=1;b:=2;c:=3;d:=4;e:=5;
  467.            move(a,s[1],5);
  468.          end.
  469.  
  470.          ┌────────────────────────────────── Watches ───────────
  471.          │ a: 1
  472.          │ b: 2
  473.          │ c: 3
  474.          │ d: 4
  475.          │ e: 5
  476.          │ a,5: 1,2,3,0,4
  477.          │ s,m: 00 01 02 03 00 04 00 00 00 00 00 00 00 00 00 00
  478.  
  479.  
  480.          And mixing bytes/words:
  481.  
  482.          program x;
  483.          {$A+,B-,D+,E+,F-,G-,I+,L+,N-,O-,P-,Q-,R-,S+,T-,V+,X+}
  484.          var a,b,c:byte; d:word; e:byte;
  485.          var s:string;
  486.          begin
  487.            a:=1;b:=2;c:=3;d:=259;e:=5;
  488.            move(a,s[1],7);
  489.          end.
  490.          ┌────────────────────────────────── Watches ─────
  491.          │ a: 1
  492.          │ b: 2
  493.          │ c: 3
  494.          │ e: 5
  495.          │ a,7: 1,2,3,0,3,1,5
  496.          │ a,7m: 01 02 03 00 03 01 05
  497.          │ s,m: 00 01 02 03 00 03 01 05 00 00 00 00 00 00
  498.          │ d,m: 03 01
  499.          │ e,2m: 05 00
  500.          │
  501.  
  502.  
  503.  
  504.          !!!  And the effect $A+ and $A- can have.
  505.  
  506.          program x;
  507.          {$A-,B-,D+,E+,F-,G-,I+,L+,N-,O-,P-,Q-,R-,S+,T-,V+,X+}
  508.          var a,b,c:byte; d:word; e:byte;
  509.          var s:string;
  510.          begin
  511.            a:=1;b:=2;c:=3;d:=259;e:=5;
  512.            move(a,s[1],7);
  513.          end.
  514.         ┌────────────────────────────────── Watches ─────
  515.         │ a: 1
  516.         │ b: 2
  517.         │ c: 3
  518.         │ e: 5
  519.         │ a,7: 1,2,3,3,1,5,0
  520.         │ a,7m: 01 02 03 03 01 05 00
  521.         │ s,m: 00 01 02 03 03 01 05 00 00 00 00 00 00 00
  522.         │ d,m: 03 01
  523.         │ e,2m: 05 00
  524.         │
  525.  
  526.          $A+ a,7: 1,2,3,0,3,1,5
  527.          $A- a,7: 1,2,3,3,1,5,0
  528.  
  529.          ($A+ has "inserted a 0" before the word-var "d" (here the "3,1")
  530.           - for details see online help on $A (put cursor on $A, press CTRL+F1)
  531.             or manuals
  532.          )
  533.  
  534.  
  535.      ....BTW...END...................
  536.      )))
  537.  
  538.  
  539.  
  540.  
  541.  
  542.  
  543.      Or, as I was suggested with a <g>, group them into records:
  544.  
  545.      program x;
  546.      const ar :record
  547.                  a,b,c,d,e:byte;
  548.                end = (a:1 ; b:2 ; c:3 ; d:4 ; e:5 );
  549.      begin
  550.      end.
  551. ╔═[■]══════════════════════════════ Watches ═════════════════════════════
  552. ║ ar: (1,2,3,4,5)
  553. ║ ar,r: (a:1;b:2;c:3;d:4;e:5)
  554. ║
  555.  
  556.      NOTE that the format-specifier ",r" adds the names of the
  557.      record-elements, which could be quite useful for larger records.
  558.  
  559.  
  560.      NOTE
  561.        Mixing CONST and VAR declaration won't be useful - the Borland's
  562.        Programmer manual indicates different "locations" for the "storage"
  563.        of CONST variables.
  564.  
  565.        That is to say for example:
  566.  
  567.         {$A- compiled}
  568.  
  569.         const byteVar:byte=$80;
  570.               userInput:string='';
  571.  
  572.         will have userInput[0] directly after byteVar -
  573.         Yet, this won't work for:
  574.  
  575.           const byteVar:byte=$80;
  576.           var   userInput:string;
  577.  
  578.         See Borland's programmer manual on details about "internals,
  579.         how variables are stored", CONST
  580.  
  581.         (again, I can't give titles or pages, since I don't have the
  582.          manuals in English
  583.         )
  584.  
  585.  
  586.  
  587.   BINARY FORMAT
  588.  
  589.      There seem to be no format-specifiers for eg. binary or octal format.
  590.      I'd suggest one of my procedures enclosed here for this conversion.
  591.  
  592.      It can surely be improved (eg. wouldn't work on x.xxxx, i.e. digits
  593.      after the "decimal"-point). Possible use while testing could be
  594.      adding test-code via $defined-compiling and then using a watch-variable
  595.      which displays the binary value.
  596.  
  597.  
  598.  -------------------------------------------------------------------------
  599.  
  600.  basisDesZahlenSystemsFuerDenString:
  601.   = the base of the system, eg 2 for binary, 8 for octal, 10 for decimal.
  602.  
  603.  dezimalzahl2string converts to "any system", just that you'd need to
  604.  expand "ch" for anything with a higher base as 16.
  605.  
  606.  
  607.  (((
  608.    BTW:
  609.      Actually the decimal-system is the odd one out. Converting from
  610.      binary to octal to hexadecimal is much easier. "laengeGruppierung"
  611.      gives the number of "chars" needed for conversion:
  612.  
  613.      8 binary chars = 3 octal chars = 2 hexa-decimal chars.
  614.  
  615.      eg: binary  11111111
  616.  
  617.         =      11 111 111
  618.        octal    3   7   7
  619.         =       1111 1111
  620.        hexa        F    F
  621.  
  622.      If you'd like some homework, convert your Compuserve-Address from
  623.      its octal format to hexa-decimal format.
  624.      Or convert the hexa-decimal value $000000000009 to decimal format.
  625.    -------------------------------------------------------------------------
  626.  )))
  627.  
  628. *)
  629.  
  630.  program x;
  631.  var pB:^Byte; w:word; s:string;
  632.  
  633.  {-DDDD---------------------------------------------------------------------}
  634.  FUNCTION dezimalzahl2string
  635.   ( zahl:longint;
  636.     basisDesZahlenSystemsFuerDenString:byte
  637.   ) :string;
  638.  CONST ch:array[0..15]of Char = '0123456789ABCDEF'; {max. für hexa-zahlen}
  639.  VAR s:string; laengeGruppierung:byte;
  640.  BEGIN
  641.    IF zahl < 0
  642.     THEN s:='-'
  643.    ELSE s[0]:=#0;
  644.    REPEAT
  645.      {Beim Restwertverfahren ergeben sich die Vorkommastellen "rückwärts"}
  646.      s:=ch[ (zahl mod basisDesZahlenSystemsFuerDenString) ] + s;
  647.      zahl:= zahl div basisDesZahlenSystemsFuerDenString;
  648.    UNTIL zahl = 0;
  649.    CASE basisDesZahlenSystemsFuerDenString OF
  650.      2:laengeGruppierung:=8;
  651.      8:laengeGruppierung:=3;
  652.      16:laengeGruppierung:=2;
  653.      ELSE laengeGruppierung:=0;
  654.    END;
  655.    IF laengeGruppierung<>0
  656.    THEN while (byte(s[0]) mod laengeGruppierung) <> 0 do s:='0'+s
  657.    ;
  658.    dezimalzahl2string:=s;
  659.  END; {dezimalzahl2string}
  660.  {--------------------------------------------------------------------------}
  661.  FUNCTION int2binStr (CONST zahl:longint):string;
  662.  VAR s:string; b:byte;
  663.  BEGIN
  664.    s:=dezimalZahl2String(zahl, 2);
  665.    b:=byte(s[0]);
  666.    while b>0 do begin
  667.      insert(' ',s,b-3);
  668.      insert('  ',s,b-7);
  669.      dec(b,8);
  670.    end;
  671.    int2BinStr:='BIN:'+s;
  672.  END; {Wandelt integer in eine Binärzahl im Format eines Strings}
  673.  {--------------------------------------------------------------------------}
  674.  begin
  675.    w:=259;
  676.  
  677.    s:='w->'+int2BinStr(w);
  678.    pB:=@w;
  679.    s:=s+' // pb->'+int2BinStr(pB^);
  680.  
  681.  { At this stage of the program, the watches would display:
  682.   ┌────────────────────────────────── Watches ───────────────────────
  683.   │ pB^,h: $3
  684.   │ pB^,2m: 03 01
  685.   │ w: 259
  686.   │ w,h: $103
  687.   │ w,m: 03 01
  688.   │ s[1],30mc: 'w->BIN:  0000 0001  0000 0011 '
  689.   │ s[30],60mc: ' // pb->BIN:  0000 0011
  690.   │
  691.  }
  692.  
  693.  
  694.    inc(pB);
  695.    s:=s+' // inc(pB)->'+int2BinStr(pB^);
  696.  
  697.  { At this stage of the program, the watches would display:
  698.   ┌────────────────────────────────── Watches ───────────────────────
  699.   │ pB^,h: $1
  700.   │ pB^,2m: 01 50
  701.   │ w: 259
  702.   │ w,h: $103
  703.   │ w,m: 03 01
  704.   │ s[1],30mc: 'w->BIN:  0000 0001  0000 0011 '
  705.   │ s[30],60mc: ' // pb->BIN:  0000 0011 // inc(pB)->BIN:  0000 0001
  706.   │
  707.  }
  708.  END.
  709.  
  710.  
  711.  
  712.  If you look at "w" as its value:
  713.      'w->BIN:  0000 0001  0000 0011 '
  714.  
  715.  inc(pB) seems to move "from the right to the left":
  716.  
  717.                 pb->BIN:  0000 0011
  718.  inc(pB)->BIN: 0000 0001
  719.  
  720.  This is not the case. As mentioned you need to look at "w",
  721.  as it is stored in memory, which is what "w,m" displays.
  722.  Hence pB did move from "the left to the right" as to be expected.
  723.  
  724.  
  725.  
  726.  
  727. (Copyright)Armin Schmitt at 100552.1041@compuserve.com
  728. Nov-1995,
  729. jC,v960224
  730.  
  731.  
  732.  Homework:
  733.  
  734.  octal                      100552.1041
  735.  =        1   0   0   5   5   2   .   1   0   4   1
  736.  =bin.  001 000 000 101 101 010   . 001 000 100 001
  737.  =           001000000101101010   . 001000100001
  738.  =       00 1000 0001 0110 1010   . 0010 0010 0001
  739.  =hexa.dec.    8    1    6    A   .    2    2    1
  740.  =
  741.  hexadecimal                  816A.221
  742.  
  743.  
  744.  hexadecimal $000000000009
  745.  =
  746.  decimal 9.0000000000000
  747.  
  748.